#include "stdafx.h"
#include "punto.h"
//--------------------------------------------------------------------------------------------/

punto::punto() {}
//--------------------------------------------------------------------------------------------/

punto::punto(float X, float Y)
{
	this->X = X;
	this->Y = Y;
}
//--------------------------------------------------------------------------------------------/

void punto::setX(float X)
{
	this->X = X;
}
//--------------------------------------------------------------------------------------------/

void punto::setY(float Y)
{
	this->Y = Y;
}
//--------------------------------------------------------------------------------------------/

float punto::getX()
{
	return this->X;
}
//--------------------------------------------------------------------------------------------/

float punto::getY()
{
	return this->Y;
}
//--------------------------------------------------------------------------------------------/

//funcion para dibujar solo un pixel
void punto::ponerUnPixel(SDL_Surface * s, int posicionX, int posicionY, color color)
{

	Uint32 mezcla;
	
	//transformo color
	mezcla = SDL_MapRGB(s->format, color.getRojo(), color.getVerde(), color.getAzul());
	punto::ponerUnPixel(s,posicionX,posicionY,mezcla);
	
}


//funcion para dibujar solo un pixel
void punto::ponerUnPixel(SDL_Surface * s, int posicionX, int PosicionY, Uint32 mezcla)
{

	Uint8 red,green,blue;
	SDL_GetRGB(mezcla,s->format,&red,&green,&blue);

	color* col = new color((int)red,(int)green,(int)blue);

	Uint8 *aux1; //Auxiliar del buffer para 8 bpp
	Uint16 *aux2; //Idem para 16 bpp
	Uint8 *aux3;
	Uint32 *aux4;


	if (posicionX <= s->w && PosicionY <= s->h && posicionX >= 0 && PosicionY >= 0) {
		//bloqueo surface
		if (SDL_MUSTLOCK(s)) 
		{
			if (SDL_LockSurface(s) < 0) 
			{
				return;
			}
		}

		//segun el bytes por pixel (BPP)
		switch (s->format->BytesPerPixel)
		{
		case 1: 
		{
			//  8-bpp
			aux1 = (Uint8 *) s->pixels + PosicionY * s->pitch + posicionX;
			*aux1 = mezcla; //Pongo el color
		}
			break;

		case 2: 
		{
			// 16-bpp
			aux2 = (Uint16 *) s->pixels + PosicionY * s->pitch / 2 + posicionX;
			*aux2 = mezcla;
		}
			break;

		case 3: 
		{
			// 24-bpp generalmente no se llega a usar  */
			aux3 = (Uint8 *) s->pixels + PosicionY * s->pitch + posicionX;
			*(aux3 + s->format->Rshift / 8) = col->getRojo();
			*(aux3 + s->format->Gshift / 8) = col->getVerde();
			*(aux3 + s->format->Bshift / 8) = col->getAzul();
		}
			break;

		case 4: 
		{
			//32-bpp menos usado
			aux4 = (Uint32 *) s->pixels + PosicionY * s->pitch / 4 + posicionX;
			*aux4 = mezcla;
		}
		//	break;
		}

		//desbloqueo surface
		if (SDL_MUSTLOCK(s)) 
		{
			SDL_UnlockSurface(s);
		}

		//actualizo el screen
		SDL_UpdateRect(s, posicionX, PosicionY, 1, 1);
	}
}


Uint32 punto::getPixel(SDL_Surface *surface, int x, int y) {
	int bpp = surface->format->BytesPerPixel;
	
	Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

	switch(bpp) {
	case 1:
		return *p;

	case 2:
		return *(Uint16 *)p;

	case 3:
		if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
			return p[0] << 16 | p[1] << 8 | p[2];
		else
			return p[0] | p[1] << 8 | p[2] << 16;

	case 4:
		return *(Uint32 *)p;

	default:
		return 0; 
	}
	
}


//--------------------------------------------------------------------------------------------/

punto::~punto() {

};
//--------------------------------------------------------------------------------------------/



